;(()=>{
    return [
        {"label":"输出函数内容",
         "contend":`
            var foo = {n:1};
            (function(foo){
                console.log(foo.n);
                foo.n = 3;
                var foo = {n:2};
                console.log(foo.n);
            })(foo);
            console.log(foo.n);
         `,
         "desc":"第一步：进行预编译，var全局变量foo、匿名函数 function、var局部变量foo  第二步：代码自上而下、自左向右执行计算： 对全局变量foo进行赋值foo={n:1}；注意：此值为对象，属于引用类型； 匿名函数传入参数foo={n:1}自执行； console.log(foo);打出数字1； 由于存在foo局部变量，那么对foo变量进行赋值foo={n:3}，同时更改了引用类型的参数值，全局foo变量被重新赋值foo={n:3}； 对局部变量foo进行重新赋值foo={n:2}; console.log(foo);打出数字2； 全局变量foo={n:3},因此，console.log(foo);打出数字3；",
         "result":"1 2 3"
        },
        {"label":"执行以下程序，输出结果为",
         "contend":()=>{
            function Foo() {
                var i = 0;
                return function() {
                    console.log(i++);
                }
            }
            var f1 = Foo();
            var f2 = Foo();
            f1();
            f1();
            f2();
         },
         "desc":"每次调用外部函数Foo()时，都会开辟一个新的内存空间，这个内存空间保存着自由变量i。由于内部的匿名函数使用了Foo函数的自由变量i，让该变量可以延迟使用，因此第一个调用f1()时输出自由变量i的值为0，第二次调用f1()时输出自由变量i的值为1，又由于f1和f2是两次Foo()调用返回的结果，它们的i值是保存在不同的内存空间上，也就没有任何关系，故第一次调用f2()输出的结果为0",
         "result":"0 1 0"
        },
        {"label":"输出函数内容",
         "contend":" A: NaN == NaN \n B: null == undefined \n C '': == 0 \n D: true == 1" ,
         "desc":"NaN无论与谁比较，包括它自己，结果都是false，",
         "result":"A"
        },
        {"label":"执行完如下程序后，所有能被访问到的变量是",
         "contend":`
            var a = 1;
            b = 2;
            eval('var c = 3');
            delete a;
            delete b;
            delete c;
         `,
         "desc":"eval中声明的变量可以被删除，其他var不能，未声明的也可以删除",
         "result":"a"
        },
        {"label":"上面这段代码运行后的输出是",
         "contend":`
            (function() {
                var a = b = 5;
            })();   
            console.log(b);
            console.log(a);
         `,
         "desc":"var a=b=5相当于 var a=5,b=5,b是全局变量",
         "result":'5 /n 报错'
        },
        {"label":"如下代码,执行后结果是？",
         "contend":`
         var label="World!";
         (function(){
             var label;
             if(typeof label=== 'undefined'){
                 label='Jack';
                 console.log('Goodbye'+label);
             }
             else{
                 console.log('hello'+label);
             }
         })();
         `,
         "desc":"js搜索变量是从内部顺原型链往外部找的，内部直接找到了label，就不去外部了，执行第一次if时还没初始化值，所以为undefined，然后赋值，执行console，结束，",
         "result":'Goodbye jack'
        },
        {"label":"以下JS代码的输出结果以及变量i的值是？",
         "contend":`
         var i = 100;
         function foo() {
             bbb: try {
                 console.log("position1");
                 return i++;  }
             finally {
                 break bbb;
             }
             console.log("position2");
             return i;
         }
         foo();
         `,
         "desc":"",
         "result":'position1、position2、101'
        },
        {"label":"上面这段代码运行后得到的结果分别是什么？",
         "contend":`
         console.log(([])?true:false); 
         console.log(([]==false?true:false)); 
         console.log(({}==false)?true:false) 
         `,
         "desc":"三元运算会进行类型转换，相当于 [] == true。 ==类型转换偏爱数字类型，所以 [] => 0 , {} => NaN",
         "result":'true , true ,false'
        },
        {"label":"以下JS代码输出的结果是什么？",
         "contend":`
         let obj = {
            num1: 117
          }
          let res = obj;
          obj.child = obj = { num2: 935 };
          var x = y = res.child.num2;
          console.log(obj.child);
          console.log(res.num1);
          console.log(y); 
         `,
         "desc":`
         obj.child = obj = { num2: 935 };
         先声明： obj = {num1: 117 , child} res = {num1: 117 , child}  
         再赋值： obj.child =  { num2: 935 } res = {num1: 117 , child:{ num2: 935 }}  
         `,
         "result":'true , true ,false'
        },
        {"label":"请问以下JS代码的输出结果会是什么",
         "contend":`
         var a = 'w' 
        let obj = {
        a: 'o',
        print: function() {
            console.log(this.a);
        },
        print2: () => { 
            console.log(this.a);
        }
        }
        let p = obj.print;
        let p2 = obj.print2;
        obj.print();
        obj.print2();
        p();
        p2();
         `,
         "desc":`
         obj.print(); this指向obj
         obj.print2(); 箭头函数，无函数包裹 指向windos
         p(); windows
         p2(); windows
         `,
         "result":'o,w,w,w'
        },
        {"label":"以下JS代码最终输出的结果和num值分别是多少？",
         "contend":`
         var test = (function() {
            var num = 0
            return () => {
                return num++
            }
          }())
          for (var i = 0; i < 20; i++) {
            test()
          }
          console.log(test());
         `,
         "desc":`
          test = ()=>{return num++}
          for循环结束后,i = 19
          再次调用： 打印i = 20,是值为21
         `,
         "result":'20,21'
        },
        {"label":"下面这段JavaScript代码的的输出是什么？",
         "contend":`
         var myObject = {
            foo: "bar",
            func: function() {
                var self = this;
                console.log(this.foo);   
                console.log(self.foo);   
                (function() {
                    console.log(this.foo);   
                    console.log(self.foo);   
                }());
            }
        };
        myObject.func();
         `,
         "desc":`
         1.第一个this.foo输出bar，因为当前this指向对象myObject。 
         2.第二个self.foo输出bar，因为self是this的副本，同指向myObject对象。 
         3.第三个this.foo输出undefined，因为这个IIFE(立即执行函数表达式)中的this指向window。 
         4.第四个self.foo输出bar，因为这个匿名函数所处的上下文中没有self，所以通过作用域链向上查找，从包含它的父函数中找到了指向myObject对象的self。
         `,
         "result":'bar bar undefined bar'
        },
        {"label":"在浏览器控制台中执行以下代码，输出的结果是?",
         "contend":`
         function test() {
            var n = 4399;
            function add(){
                n++;
                console.log(n);
            }
            return {n:n,add:add}
        }
        var result = test();
        var result2 = test();
        result.add();
        result.add();
        console.log(result.n);
        result2.add();
         `,
         "desc":`懵逼点在第三个，这里{n：n}是对变量n里的值进行缓存，而不是本身n这个指针变量，这样生成add的时候n指向的值是多少{n：n}里的值就是多少`,
         "result":'4400 4401 4399 4400'
        },
        {"label":"在浏览器控制台中执行以下代码，输出的结果是?",
         "contend":`
         function test() {
            var n = 4399;
            function add(){
                n++;
                console.log(n);
            }
            return {n:n,add:add}
        }
        var result = test();
        var result2 = test();
        result.add();
        result.add();
        console.log(result.n);
        result2.add();
         `,
         "desc":`懵逼点在第三个，这里{n：n}是对变量n里的值进行缓存，而不是本身n这个指针变量，这样生成add的时候n指向的值是多少{n：n}里的值就是多少`,
         "result":'4400 4401 4399 4400'
        },
    ]
})()